package com.doom.kotlindemo

import java.lang.Exception
import java.lang.NumberFormatException

// 单例类
object Demo {

    // 函数
    fun test() {
//        logd<Demo>("test");

        // 基本数据类型
        // Byte   8
        // Short  16
        // Int    32
        // Long   64
        // Float  32
        // Double 64
        // String
        // Char
        // Boolean

        // 可变变量
//        var name: String;
//        name = "name";
//        println("name ${name}")

        // 类型推断
//        var type = "type"
//        println("type:${type}")

        // 不可变变量
//        val maxAge: Int = 10;
//        maxAge = 20; // 如果修改的话，编译报错：Val cannot be reassigned

//        var value: Int = null; // 不为空的可变变量; 编译报错: Null can not be a value of a non-null type Int
//        var value: Int = 0; // 不为空的可变变量; 输出：System.out: value is : 0
//        var value: Int? = null; // 可以为空的可变变量; 输出：System.out: value is : null
//        println("value is : $value");

//        var dataClass = DataClass(1);
//        println("dataClass is : $dataClass");
//        var dataClass2 = dataClass.copy(2)
//        println("dataClass2 is : $dataClass2");
//        输出：
//        System.out: dataClass is : DataClass(id=1)
//        System.out: dataClass2 is : DataClass(id=2)

        // ==  ！= 比较对象内容
        // ===  ！==  比较对象引用

//        // if else 判断
//        var type = 1
//        if (type >= 1){
//            println("type >= 1")
//        }else{
//            println("type < 1")
//        }
//
//        // 三目运算
//        var isSingleType: Boolean = if(type >= 1) true else false
//        println("isSingleType:${isSingleType}")
//
//        var typeValue = if(isSingleType) 1 else 0;
//        println("typeValue:${typeValue}")
//
//        // is 类型判断
//        if(isSingleType is Boolean){
//            println("isSingleType is Boolean")
//        }else{
//            println("isSingleType is not Boolean")
//        }
//        if(typeValue is Int){
//            println("typeValue is Int")
//        }else{
//            println("typeValue is not Int")
//        }

        // when
//        var type = 1;
//        when (type) {
//            1, 10 -> {
//                println("type 1, 10");
//            }
//            99 -> {
//                println("type 99");
//            }
//            else -> {
//                println("type else");
//            }
//        }

        // when赋值
//        var typeValue = when(type) {
//            1, 10 -> {
//                "1,10";
//            }
//            99 -> {
//                "99";
//            }
//            else -> {
//                "else";
//            }
//        }
//        println("typeValue:${typeValue}")

        //循环逻辑 while do-while for
//        var index = 1;
//        while(index < 1){
//            println("index ${index++}")
//        }
//        index = 1;
//        do{
//            println("index ${index++}")
//        }while(index < 1)

//        var names = arrayOf("1", "2", "3");
//        for(name in names){
//            println("name:${name}");
//        }

//        for(i in names.indices){
//            println("i:${i} name:${names[i]}");
//        }

//        for((i, name) in names.withIndex()){
//            println("i:${i} name:${names[i]}");
//        }

//        for(i in 1..5) {
//            logd<Demo>("i:${i} ");
//        }

        // 异常处理 try catch finally
//        val value = "s1";
//        var out: Int? = null;
//
//        try{
//            out = Integer.parseInt(value);
//        }catch (e: NumberFormatException){
//            logd<Demo>("NumberFormatException" + e.message.toString());
//        }catch (e: Exception){
//            logd<Demo>("Exception" + e.message.toString());
//        }finally {
//            logd<Demo>("finally");
//        }
//
//        var output = try{
//            Integer.parseInt(value)
//        }catch (e: Exception){
//            -1
//        }
//        logd<Demo>("output is ${output}");

        // 类
//        val classA = ClassA("thisname");
//        classA.print()
//
//        val match = Match("name", "away", "date");
//        logd<Demo>(match.getMatchInfo());

        // 类继承 open关键字 构造器的使用
//        var car = Car("Toyota");
//        var lexus = Lexus();
//        var honda = Honda();
//
//        car.showBrand()
//        lexus.showBrand()
//        honda.showBrand()

        // 接口 interface
//        var oracle = Oracle("CONNSTRING");
//        oracle.showInfo()
//        oracle.connect()
//        oracle.close()

        // 匿名类实现接口
//        var mockDB = object : IDatabase {
//            override fun connect() {
//                logd<Demo>("connect");
//            }
//
//            override fun close() {
//                logd<Demo>("close");
//            }
//        }
//        mockDB.connect();
//        mockDB.close();

        // Null空安全
//        var title: String?;
//        title = null;
//        title = "null";

//        var len = title.length; // 编译报错：Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String?
//        var len = title?.length; // 如果为空，返回null
//        var len = title!!.length // 跳过检测，运行报错：Caused by: kotlin.KotlinNullPointerException
//        logd<Demo>("title:${title} len:${len}");

        // 范围的使用
//        for (i in 1..5) { // 1,2,3,4,5
//        for (i in 1 until 5) { // 1,2,3,4
//        for (i in 1..5 step 2) { // 1,3,5
//        for(i in 5 downTo 1) {
//            logd<Demo>("i:${i}");
//        }
//
//        var num = 5;
//        if(num in 1..10) {
//            logd<Demo>("num ${num} is in 1..10");
//        }

        // 扩展函数
//        var value: String = "unknown"
//        logd<Demo>("value:${value}");
//        logd<Demo>(value.add(10, 20));

        // with语法
//        val oracle = Oracle("CONNSTRING");
//        with(oracle){
//            connect()
//            close()
//        }




    }
}

// data class 自动补充实现 toString copy hashCode 函数
data class DataClass(var id: Int)

// 类定义
class ClassA {
    var name: String = ""

    // 次构造函数（二级构造函数）
    constructor(name: String) {
        this.name = name;
    }

    fun print() {
        logd<Demo>("name is: ${name}");
    }
}

// 类定义
class Match /*constructor*/(val home: String, val away: String, val date: String) {
    fun getMatchInfo(): String {
        return "${home} ${away} ${date}"
    }
}

// 类继承
open class Car /*constructor*/(brand: String) {
    var brand: String = brand;

    fun showBrand() {
        logd<Demo>("brand is ${brand}");
    }
}

class Lexus: Car("Lexus"){

}

class Honda: Car("Honda") {

}

// 接口
interface IDatabase {
    fun connect()
    fun close()
}

// 抽象类
abstract class Database /*constructor*/(databaseName: String) : IDatabase {
    val databaseName: String = databaseName;

    var connString: String = "";

    fun showInfo() {
        logd<Demo>("database is :${databaseName}");
    }
}

class Oracle /*constructor*/(connString: String) : Database("Oracle") {
    // 初始化代码（主构造器中不能包含任何代码）
    init {
        super.connString = connString
    }

    override fun connect() {
        logd<Demo>("connect :${connString}");
    }

    override fun close() {
        logd<Demo>("close :${connString}");
    }
}

fun String.add(x: Int, y: Int): Int {
    return x+y;
}





